home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 3 / CD ACTUAL 3.iso / linux / sonido / mod-0.000 / mod-0 / mod / load_s3m.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-16  |  12.8 KB  |  537 lines
  1. /*
  2.  *  load_s3m.c - Loads Scream Tracker III modules.
  3.  *
  4.  *  (C) 1994 Mikael Nordqvist (d91mn@efd.lth.se, mech@df.lth.se)
  5.  */
  6.  
  7. #include <stdio.h>
  8. #include <unistd.h>
  9. #include <stdlib.h>
  10. #include <sys/types.h>
  11. #include <fcntl.h>
  12. #include <sys/ioctl.h>
  13. #include <sys/soundcard.h>
  14. #include <sys/ultrasound.h>
  15. #include <limits.h>
  16. #include <string.h>
  17. #include <ctype.h>
  18.  
  19. #include "mod.h"
  20.  
  21. /* External global variables */
  22.  
  23. SEQ_DECLAREBUF();
  24. extern int seqfd, gus_dev;
  25.  
  26. extern struct mod_info M;
  27. extern struct options opt;
  28.  
  29. extern char quit;
  30.  
  31. extern char effect_used[NR_EFX];
  32.  
  33. /* Local functions */
  34.  
  35. static int process_header(int, unsigned long *, unsigned short *,
  36.               unsigned char *);
  37. static int read_patterndata(int, unsigned short *, unsigned char *);
  38. static void fix_effect(unsigned char *, unsigned char *);
  39.  
  40. /* Defines and variables used while loading module */
  41.  
  42. #define S3M_HEADER_SIZE     0x60
  43. #define S3M_SAMPLEINFO_SIZE 0x50
  44.  
  45. #define S3M_NAME            0x00
  46. #define S3M_TYPE            0x1d
  47. #define S3M_SONGLENGTH      0x20
  48. #define S3M_NOS             0x22
  49. #define S3M_PATTERNS        0x24
  50. #define S3M_FLAGS           0x26
  51. #define S3M_TRACKERVERSION  0x28
  52. #define S3M_FORMATVERSION   0x2a
  53. #define S3M_MAGIC           0x2c
  54. #define S3M_GLOBALVOLUME    0x30
  55. #define S3M_SPEED           0x31
  56. #define S3M_TEMPO           0x32
  57. #define S3M_MASTERVOLUME    0x33
  58. #define S3M_CHANNELS        0x40
  59.  
  60. /* S3M_S_DATAPTR should be 0x0d and 24 bits but as the docs are a bit unclear
  61.  * we use 0x0e and 16 bits. This will work for filesizes <= 1M.
  62.  */
  63.  
  64. #define S3M_S_TYPE          0x00
  65. #define S3M_S_DOSNAME       0x01
  66. #define S3M_S_DATAPTR       0x0e
  67. #define S3M_S_LEN           0x10
  68. #define S3M_S_LOOPSTART     0x14
  69. #define S3M_S_LOOPEND       0x18
  70. #define S3M_S_VOLUME        0x1c
  71. #define S3M_S_PACKED        0x1e
  72. #define S3M_S_FLAGS         0x1f
  73. #define S3M_S_C4SPD         0x20
  74. #define S3M_S_NAME          0x30
  75. #define S3M_S_MAGIC         0x4c
  76.  
  77. #define S3M_VOLOPTIMIZATION    8
  78. #define S3M_FLAG_AMIGALIMITS  16
  79.  
  80. #define S3M_S_FLAG_LOOPED      1
  81. #define S3M_S_FLAG_STEREO      2
  82. #define S3M_S_FLAG_16BIT       4
  83.  
  84. static int version, expected_length;
  85.  
  86. int load_s3m(int fd)
  87. {
  88.     unsigned long sampledata_ptrs[256];
  89.     unsigned short pattern_ptrs[256];
  90.     unsigned char channels[32];
  91.     char tmpbuf[80];
  92.  
  93.     int i, fatalerr;
  94.  
  95.     print_status("Loading S3M");
  96.     M.nr_tracks=0;
  97.  
  98.     if(!process_header(fd, sampledata_ptrs, pattern_ptrs, channels))
  99.     return 0;
  100.  
  101.     if(!read_patterndata(fd, pattern_ptrs, channels)) {
  102.     info("Unable to read patterndata.\n");
  103.     return 0;
  104.     }
  105.  
  106.     ioctl(seqfd, SNDCTL_SEQ_RESETSAMPLES, &gus_dev);
  107.     
  108.     info("\nUploading instruments to GUS...\n");
  109.     
  110.     fatalerr=0;
  111.  
  112.     for(i=1; i <= M.nr_samples; ++i) {
  113.     if(M.sample[i].length > 4) { /* Only load non-silent samples */
  114.         if(lseek(fd, sampledata_ptrs[i-1]*16, SEEK_SET) == -1) {
  115.         info("Seek failed (%d)", sampledata_ptrs[i-1]*16);
  116.         fatalerr=1;
  117.         break;
  118.         } else if(!read_and_upload_sample(fd, i)) {
  119.         fatalerr=1;
  120.         break;
  121.         }
  122.     }
  123.     if(quit == QUIT_SIGNAL) /* Bail out if we got QUIT_SIGNAL */
  124.         return 0;
  125.     }
  126.     
  127.     if(fatalerr) {
  128.     sprintf(tmpbuf, "Unable to load sample %d", i);
  129.     print_status(tmpbuf);
  130.     info("\nUnable to load sample %d.\n", i);
  131.     sleep(1);
  132.     return 0;
  133.     }
  134.  
  135.     print_songname(M.name);
  136.     print_samples(1);
  137.     print_songinfo(M.nr_voices, M.nr_samples, "S3M", expected_length,
  138.            M.songlength, M.nr_patterns);
  139.     return 1;
  140. }
  141.  
  142.  
  143. static int process_header(int fd, unsigned long *sampledata_ptrs,
  144.               unsigned short *pattern_ptrs, unsigned char *channels)
  145. {
  146.     unsigned char buf[S3M_HEADER_SIZE];
  147.     int tmp, i, silent_sample;
  148.     struct sample_info *s;
  149.     short s3m_flags;
  150.     unsigned short sample_ptrs[256];
  151.  
  152.     if(read(fd, buf, S3M_HEADER_SIZE) != S3M_HEADER_SIZE) {
  153.     info("Unable to read header from file.\n");
  154.     return 0;
  155.     }
  156.     expected_length=S3M_HEADER_SIZE;
  157.  
  158.     if(strncmp("SCRM", &buf[S3M_MAGIC], 4)) {
  159.     info("Not a Scream Tracker III module.\n");
  160.     return 0;
  161.     }
  162.  
  163.     if(buf[S3M_TYPE] != 16)
  164.     info("Type-field in header does not equal ST3. Trying anyways.\n");
  165.     
  166.     tmp=*(short*)&buf[S3M_TRACKERVERSION];
  167.     version=*(unsigned short *)&buf[S3M_FORMATVERSION];
  168.     info("Tracker version %d.%0x  Format version %d\n",
  169.      (tmp>>8)&0x0f, tmp&0xff, version);
  170.     
  171.     strncpy(M.name, &buf[S3M_NAME], 0x1b);
  172.     M.name[0x1b]=0;
  173.     fix_string(M.name);
  174.  
  175.     /* Global / master volume currently ignored */
  176.     opt.speed=buf[S3M_SPEED];
  177.     opt.tempo=buf[S3M_TEMPO];
  178.     
  179.     M.songlength=*(short *)&buf[S3M_SONGLENGTH];
  180.     M.nr_samples=*(short *)&buf[S3M_NOS];
  181.     M.nr_patterns=*(short *)&buf[S3M_PATTERNS];
  182.     
  183.     if(!M.nr_samples || M.nr_samples > 255) {
  184.     info("Invalid number of samples in module.\n");
  185.     return 0;
  186.     }
  187.     
  188.     if(M.nr_patterns > 255) {
  189.     info("Invalid number of patterns.\n");
  190.     return 0;
  191.     }
  192.     
  193.     s3m_flags=*(short *)&buf[S3M_FLAGS];
  194.     if(s3m_flags&S3M_FLAG_AMIGALIMITS) {
  195.     opt.low_note=BASE_NOTE+3*12;
  196.     opt.high_note=BASE_NOTE+6*12-1;
  197.     info("Amiga limits.\n");
  198.     }
  199.     else {
  200.     opt.low_note=BASE_NOTE+0*12;
  201.     opt.high_note=BASE_NOTE+8*12-1;
  202.     }
  203.     if(s3m_flags&S3M_VOLOPTIMIZATION)
  204.     info("Volume optimization flag set in module (not supported yet).\n");
  205.  
  206.     memcpy(channels, &buf[S3M_CHANNELS], 32);
  207.     for(i=31; i >= 0 && channels[i] >= 16; --i) /* Channel <= 15 for samples */
  208.     ;
  209.     M.nr_voices=i+1;
  210.     if(M.nr_voices <= 0 || M.nr_voices > 31) {
  211.     info("Illegal number of voices (%d).\n", M.nr_voices);
  212.     return 0;
  213.     }
  214.     
  215.     if(read(fd, M.patterntable, M.songlength) != M.songlength) {
  216.     info("Unable to read patterntable from file.\n");
  217.     return 0;
  218.     }
  219.     
  220.     if(read(fd, sample_ptrs, M.nr_samples*2) != M.nr_samples*2) {
  221.     info("Unable to read sample-pointers from file.\n");
  222.     return 0;
  223.     }
  224.     
  225.     if(read(fd, pattern_ptrs, M.nr_patterns*2) != M.nr_patterns*2) {
  226.     info("Unable to read pattern-pointers from file.\n");
  227.     return 0;
  228.     }
  229.     
  230.     expected_length+=M.songlength+M.nr_samples*2+M.nr_patterns*2;
  231.     
  232.     M.sample=(struct sample_info *)malloc((1+M.nr_samples)*
  233.                       sizeof(struct sample_info));
  234.     
  235.     print_sample_info_header();
  236.     
  237.     for(i=1; i <= M.nr_samples; ++i) {
  238.     if(lseek(fd, sample_ptrs[i-1]*16, SEEK_SET) == -1 ||
  239.        read(fd, buf, S3M_SAMPLEINFO_SIZE) != S3M_SAMPLEINFO_SIZE) {
  240.         info("Unable to read sampleheader (%d).\n", i);
  241.         return 0;
  242.     }
  243.     expected_length+=S3M_SAMPLEINFO_SIZE;
  244.     s=&M.sample[i];
  245.  
  246.     /* Valid isn't set to TRUE until it's data has been read */
  247.     bzero((void *)s, sizeof(struct sample_info));
  248.     
  249.     if(!strncmp("SCRI", &buf[S3M_S_MAGIC], 4)) {
  250.         info("Sample %d is an Adlib instrument - skipped.\n", i);
  251.         strcpy(s->name, "Adlib-instrument");
  252.         continue;
  253.     }
  254.     
  255.     silent_sample=0;
  256.     if(strncmp("SCRS", &buf[S3M_S_MAGIC], 4)) {
  257.         if(*(int *)&buf[S3M_S_MAGIC]) {
  258.         info("Bad sampleheader (%d) magic = %d %d %d %d.\n", i,
  259.              buf[S3M_S_MAGIC], buf[S3M_S_MAGIC+1], buf[S3M_S_MAGIC+2],
  260.              buf[S3M_S_MAGIC+3]);
  261.         strcpy(s->name, "Empty sample");
  262.         continue;
  263.         }
  264.         silent_sample=1;
  265.     }
  266.     
  267.     strncpy(s->name, &buf[S3M_S_NAME], 28);
  268.     s->name[28]=0;
  269.         fix_string(s->name);
  270.     strncpy(s->dosname, &buf[S3M_S_DOSNAME], 12);
  271.     s->dosname[12]=0;
  272.         fix_string(s->dosname);
  273.     
  274.     s->length=*(unsigned long *)&buf[S3M_S_LEN];
  275.     s->repeat_start=*(unsigned long *)&buf[S3M_S_LOOPSTART];
  276.     s->repeat_end=*(unsigned long *)&buf[S3M_S_LOOPEND];
  277.     s->volume=buf[S3M_S_VOLUME];
  278.     
  279.     expected_length+=s->length;
  280.     
  281.     if(buf[S3M_S_PACKED])
  282.         info("Packed sample. Trying to load it as unpacked.\n");
  283.     
  284.     if((buf[S3M_S_FLAGS]&S3M_S_FLAG_LOOPED) &&
  285.        s->repeat_end > s->repeat_start+4)
  286.         s->looped=LOOP_FORWARD;
  287.     else
  288.         s->looped=0;
  289.     
  290.     if(buf[S3M_S_FLAGS]&S3M_S_FLAG_16BIT)
  291.         s->bits_16=1;
  292.     else
  293.         s->bits_16=0;
  294.     
  295.     if(buf[S3M_S_FLAGS]&S3M_S_FLAG_STEREO)
  296.         info("Stereo-sample. Trying to load it as a mono-sample.\n");
  297.     
  298.     s->repeat_start=MIN(MAX(0, s->repeat_start), s->length-2);
  299.     s->repeat_end=MIN(MAX(0, s->repeat_end), s->length-
  300.               (s->bits_16 ? 2 : 1));
  301.  
  302.     if(version == 2)
  303.         s->unsigned_data=1;
  304.     
  305.     s->c2freq=*(long*)&buf[S3M_S_C4SPD];
  306.     
  307.     sampledata_ptrs[i-1]=(*(unsigned short*)&buf[S3M_S_DATAPTR]);
  308.     
  309.     if(silent_sample)
  310.         s->length=0;
  311.     print_sample_info(i);
  312.     }
  313.     
  314.     for(i=0; i < M.nr_voices; ++i) {
  315.     if(channels[i] <= 7)
  316.         M.panning[i]=1;  /* Left */
  317.     else if(channels[i] <= 15)
  318.         M.panning[i]=14; /* Right */
  319.     else
  320.         M.panning[i]=7;  /* Center (adlib/unused) */
  321.     }
  322.     
  323.     M.restartpos=0;
  324.     M.volrange=64;
  325.     opt.speed0stop=0; /* Ignored in S3M's */
  326.     
  327.     info("\nSamples: %d  Patterns: %d  Songlength: %d\n",
  328.      M.nr_samples, M.nr_patterns, M.songlength);
  329.     
  330.     return 1;
  331. }
  332.  
  333.  
  334. static int read_patterndata(int fd, unsigned short *pattern_ptrs,
  335.                 unsigned char *channels)
  336. {
  337.     unsigned char buf[3];
  338.     struct event *e;
  339.     int p, l, v;
  340.     struct event events[64*32];
  341.     
  342.     for(v=0; v < NR_EFX; ++v)
  343.     effect_used[v]=0;
  344.     
  345.     /* Allocate for worst case (no identical tracks) */
  346.     M.tracks=(struct event **)malloc(M.nr_patterns*M.nr_voices*
  347.                      sizeof(struct event *));
  348.     
  349.     for(v=0; v < M.nr_voices; ++v)
  350.     M.track_idx[v]=(int *)malloc(M.nr_patterns*sizeof(int));
  351.     
  352.     /* Add the empty track */
  353.     bzero((void *)events, sizeof(struct event)*64);
  354.     get_track_idx(events);
  355.     
  356.     for(p=0; p < M.nr_patterns; ++p) {
  357.     bzero(events, 64*32*sizeof(struct event));
  358.     if(lseek(fd, pattern_ptrs[p]*16, SEEK_SET) == -1)
  359.         return 0;
  360.     if(!get_bytes(fd, 0, 0))
  361.         return 0;
  362.     if(!get_bytes(fd, buf, 2)) /* Don't trust length-value */
  363.         return 0;
  364.     expected_length+=2;
  365.     for(l=0; l < 64; ++l) {
  366.         while(1) {
  367.         if(!get_bytes(fd, buf, 1))
  368.             return 0;
  369.         expected_length++;
  370.  
  371.         if(!buf[0])
  372.             break;
  373.         
  374.         e=&events[(buf[0]&0x1f)*64+l];
  375.         if(buf[0]&32) {
  376.             if(!get_bytes(fd, &buf[1], 2))
  377.             return 0;
  378.             expected_length+=2;
  379.             switch(buf[1]) {
  380.               case 255:
  381.             e->note=0;
  382.             break;
  383.               case 254:
  384.             e->note=NOTE_OFF;
  385.             break;
  386.               default:
  387.             e->note=((buf[1]>>4)&0x0f)*12+(buf[1]&0x0f)+BASE_NOTE;
  388.             }
  389.             e->sample=buf[2];
  390.         }
  391.         if(buf[0]&64) {
  392.             if(!get_bytes(fd, &buf[1], 1))
  393.             return 0;
  394.             expected_length++;
  395.             e->effect2=EFX_VOLUME;
  396.             e->arg2=buf[1];
  397.         }
  398.         if(buf[0]&128) {
  399.             if(!get_bytes(fd, &buf[1], 2))
  400.             return 0;
  401.             expected_length+=2;
  402.             e->effect=buf[1];
  403.             e->arg=buf[2];
  404.         }
  405.         fix_effect(&e->effect, &e->arg);
  406.         if(e->effect || (!e->effect && e->arg))
  407.             effect_used[e->effect]=1;
  408.         }
  409.     }
  410.     for(v=0; v < M.nr_voices; ++v)
  411.         M.track_idx[v][p]=(channels[v] == 255 ? 0 :
  412.                 get_track_idx(&events[v*64]));
  413.     }
  414.     print_used_effects();
  415.     
  416.     return 1;
  417. }
  418.  
  419. /* Converts the Scream Tracker effectnumbers to those used by the player.
  420.  */
  421.  
  422. static void fix_effect(unsigned char *effect, unsigned char *arg)
  423. {
  424.     unsigned char e=*effect+'A'-1, a=*arg;
  425.  
  426.     if(!*effect) {
  427.     *arg=0;
  428.     return;
  429.     }
  430.  
  431.     if(e < 'A' || e > 'Z') {
  432. #if 0
  433.     debug("Invalid EFX (%d '%c'.\n", e, e);
  434. #endif
  435.     *effect=*arg=0;
  436.     return;
  437.     }
  438.     
  439.     switch(e) {
  440.       case 'A': e=EFX_SPEED; break;
  441.       case 'B': e=EFX_JUMP; break;
  442.       case 'C': e=EFX_BREAK; break;
  443.       case 'D':
  444.     if(!a) {
  445.         e=EFX_VOLSLIDECONTINUE;
  446.     }
  447.     else if((a&0x0f) == 0x0f && a != 0x0f) {
  448.         e=EFX_FINEVOLSLIDEUP;
  449.         a=(a>>4)&0x0f;
  450.     }
  451.     else if((a&0xf0) == 0xf0 && a != 0xf0) {
  452.         e=EFX_FINEVOLSLIDEDOWN;
  453.         a&=0x0f;
  454.     }
  455.     else {
  456.         e=EFX_VOLSLIDE;
  457.     }
  458.     break;
  459.       case 'E':
  460.     if(!a) {
  461.         e=EFX_PORTADOWNCONTINUE;
  462.     }
  463.     else if(a >= 0xf0) {
  464.         e=EFX_FINEPORTADOWN;
  465.         a&=0x0f;
  466.     }
  467.     else if(a >= 0xe0) {
  468.         e=EFX_EXTRAFINEPORTADOWN;
  469.         a&=0x0f;
  470.     }
  471.     else {
  472.         e=EFX_PORTADOWN;
  473.     }
  474.     break;
  475.       case 'F':
  476.     if(!a) {
  477.         e=EFX_PORTAUPCONTINUE;
  478.     }
  479.     else if(a >= 0xf0) {
  480.         e=EFX_FINEPORTAUP;
  481.         a&=0x0f;
  482.     }
  483.     else if(a >= 0xe0) {
  484.         e=EFX_EXTRAFINEPORTAUP;
  485.         a&=0x0f;
  486.     }
  487.     else {
  488.         e=EFX_PORTAUP;
  489.     }
  490.     break;
  491.       case 'G': e=EFX_PORTANOTE; break;
  492.       case 'H': e=EFX_VIBRATO; break;
  493.       case 'I': e=EFX_TREMOR; break;
  494.       case 'J': e=EFX_ARPEGGIO; break;
  495.       case 'K': e=EFX_VIBRATOVOLSLIDE; break; /* "Retrig" for value 00 ?!?! */
  496.       case 'L': e=EFX_PORTANOTEVOLSLIDE; break;
  497.     
  498.       case 'O': e=EFX_SAMPLEOFFSET_S3M; break;
  499.       case 'Q': e=EFX_RETRIGGERVOLSLIDE; break;
  500.       case 'R': e=EFX_TREMOLO; break;
  501.       case 'S': e=EFX_EXTENDED; break;
  502.       case 'T': e=EFX_TEMPO; break;
  503.       case 'V': e=EFX_GLOBALVOLUME; break;
  504.     
  505.       default:
  506.     e=a=0;
  507.     }
  508.     
  509.     if(e == EFX_EXTENDED) {
  510.     e=(a>>4)&0x0f;
  511.     a&=0x0f;
  512.     switch(e) {
  513.       case 2:
  514.         e=EFX_FINETUNE;
  515.         a=(a-8)&0x0f;
  516.         break;
  517.       case 3: e=EFX_VIBWAVEFORM; break;
  518.       case 4: e=EFX_TREMWAVEFORM; break;
  519.       case 0x0b: e=EFX_LOOP; break;
  520.       case 0x0c: e=EFX_NOTECUT; break;
  521.       case 0x0d: e=EFX_NOTEDELAY; break;
  522.       case 0x0e: e=EFX_PATTERNDELAY; break;
  523.         
  524.         /* Effects not implemented in ST3 */
  525.       case 0:    /* EFX_FILTER    */
  526.       case 1:    /* EFX_GLISSANDO */
  527.       case 0x0a: /* Previous Stereo-control, but remved in ST3 */
  528.       case 0x0f: /* EFX_INVERTEDLOOP/EFX_FUNK */
  529.       default:
  530.         e=a=0;
  531.     }
  532.     }
  533.     
  534.     *arg=a;
  535.     *effect=e;
  536. }
  537.